Go Programming - Basics

Concepts of Programming Languages

Organisational matters

• Some missing students last time
• Questions

Characteristics of a Successful Language (Suggestion)

• Simplicity and readability (Small instruction set and easy syntax)
• Abstraction (types/classes, Generics, Procedures ....)
• Efficiency
• Reliability (compatibility, error checking, no memory leaks)
• Dependency management
• Good support and documentation (public compilers, tutorials, community, IDE)
• Orthogonality

What is an Orthogonal language

• Def 1: A language is orthogonal if its features are built upon a small, mutually independent set of primitive operations.
• Def 2: We can combine the majority of the language constructs in many ways without any side effects
• Other definitions: https://stackoverflow.com/questions/3272019/is-java-orthogonal
• Associated with simplicity and consistency.
• The more orthogonal the design, the fewer exceptions.
• The Go language was designed with orthogonality in mind.

Types VS. Functions (Non-Orthogonal Design by example)

• E. g. in C, the type system is not orthogonal to the function system.

// Ints are allowed to return
int returnint() {
    return 1;
}

// Structs are allowed to return
typedef struct{} structdef;
structdef returnstruct() {
    structdef mystruct;
    return mystruct;
}

// Arrays are not allowed to return
int[3] returnarray() {
    static int myarray[3] = {1, 2, 3};
    return myarray;
}

• But arrays in structs are allowed to return

Other non-orthogonal examples

• In C, "a++" behaves different for an integer a than for a pointer a.

-- Go doesn't allow this operation.

• In Java, there are three kinds of loops: for, while, do-while.

-- In Go, there is only one loop: for

• In Java the way variables are stored depends on their types.

int x; // x is a value
MyClass y; // y is a reference

-- Go has pointers and values. But the way they are stored is the same.

Golang

Golang

• Go is an open source programming language for distributed and parallel systems
• Go addresses the problems of C ++ backend development at Google
• The Go core team is prominent: Robert Griesheimer (Hotspot VM), Ken Thompson (UX / B) and Rob Pike (UTF-8)
• Go is actively developed since 2008
• Go is THE language behind the Cloud Native Stack

www.cncf.io/

• All essential components are written in Go: Docker, Kubernetes, Etcd, Prometheus, Grafana -> An important reason to take a closer look at Go

Tools

go env Print Go environment information

go run file.go just runs the code. Can be multiple files, too.

go build downloads dependencies and builds the executable, but needs a go.mod file.

go tool dist list list all supported platforms

env GOOS=darwin GOARCH=arm64 go build Build for Apple ARM CPU computers.

go fmt formats your files

go mod init creates a go.mod module file

• module file contains language version information, module name and dependencies

go mod tidy updates the go mod file if you add more dependencies

Packages

package main

import (
    "fmt"
)

func main() {
    fmt.Printf("Hello %s", "Programming with Go \xE2\x98\xAF\n") // \xE2\x98\xAF -> ☯
    fmt.Printf("Hello %s", "Programming with Go ☯\n")
}

• The entry point for Go executable is always the function main in package main (main.main)
• New packages need a new directory and can then be referenced
• Public functions begin with a capital letter

Primitive Types

• In Go the type of a variable is behind the name!

Complex Numbers

package main

import (
    "fmt"
    "math/cmplx"
)

func main() {
    c := 3 + 4i
    fmt.Printf("c=%v\n", c)
    r, θ := cmplx.Polar(c) // Go supports variables with unicode characters
    fmt.Printf("r=%v, θ=%v\n", r, θ)
}

• The assignment ':=' is used for short variable declarations. The type is deduced implicitly. Also called "type inference"

Weak typing vs. Strong typing I

Languages differ of how serious they handle the type

• type conversions implicit or explicit
• strict or loose typing rules at compile time
• dynamic types (runtime types) allowed or not

Weak typing vs. Strong typing II

• weakly typed: allow implicit conversions
• strongly typed: don't allow implicit conversions
• statically typed: type checking at compile time
• dynamically typed: type checking at runtime

Go uses a strong typing system. But why?

Weak typing vs. Strong typing II

Where implicit type conversion in C goes wrong

int main() {
    signed int a = -1;
    unsigned int b = 0;

    if (a < b) {
        printf("a ís smaller than b\n");
    }

    return 0;
}

Javascript is very creative with type coercion

Strong typing in Go

package main

import "fmt"

func main() {
    var a int32 = -1
    var b uint32 = 2

    if a < int32(b) {
        fmt.Printf("a is smaller than b")
    }
}

• In Go there is no implicit type cast.
• The compiler will complain if you try to compare different types.
• You have to do the type conversion explicitly.

Golang - some details

Go has a dynamic type: any

func PrintVariableDetails(v any) {
    typeof := reflect.TypeOf(v)
    fmt.Printf("The variable with type '%s' has the value '%v'\n", typeof.Name(), v)
}

func main() {
    var someValue any
    someValue = 2
    PrintVariableDetails(someValue)

    someValue = "abcd"
    PrintVariableDetails(someValue)

    if tmp, ok := someValue.(string); ok {
        fmt.Println("someValue is a string and has the value", tmp)
    }
}

Maps

• Maps are Go's built-in associative data type (sometimes called hashes or dicts in other languages).

func countWords(input string) map[string]int {

    // Split the string into words using whitespace as a delimiter
    words := strings.Fields(input)

    // Initialize an empty map to store word counts
    wordCounts := make(map[string]int)

    // Iterate over the words and update the count in the map
    for _, word := range words {
        word = strings.ToLower(word) // Convert word to lowercase to ensure case-insensitivity
        wordCounts[word]++           // Increment the count for this word
    }

    return wordCounts
}

Arrays and Slices

• Arrays have a fixed length and can not be resized
• Slices are views to underlying arrays or can be created dynamically
• Slices can be resized (append())
• The underlying array grows automatically (if needed)
• Both have a length and a capacity: What does that mean?

arr := [5]int{1, 2, 3, 4, 5}

s := arr[0:2]

fmt.Println(len(s), cap(s)) // ==> 2, 5

s = append(s, 8)
s = append(s, 9)
s = append(s, 10)
s = append(s, 11)

fmt.Println(len(s), cap(s)) // ==> 6, 10

Functions and Control Structures: Example Palindrome

// IsPalindrome implementation. Does only work for 1-Byte UTF-8 chars (ASCII).
func IsPalindrome(word string) bool {
    for pos := 0; pos < len(word)/2; pos++ {
        if word[pos] != word[len(word)-pos-1] {
            return false
        }
    }
    return true
}

• The return type of a function is behind the parameter list
• Conditions (if, for) are not clipped with ()
• if, for ... statements need curly braces {}
• semicolons are omitted

Go directly supports Unit Tests via "go test"

// palindrome_test.go
func TestPalindrome(t *testing.T) {
    if !IsPalindrome("") {
        t.Error("isPalindrome('' should be true. But is false.")
    }
    if !IsPalindrome("o") {
        t.Error("isPalindrome('o' should be true. But is false.")
    }
    if !IsPalindrome("oto") {
        t.Error("isPalindrome('oto' should be true. But is false.")
    }
    if IsPalindrome("ottos") {
        t.Error("isPalindrome('ottos' should be false. But is true.")
    }
}

• The unit test for a file is located in a _test.go file of the same name
• TestXY functions are called automatically
• The test context testing.T controls the execution
• Has anyone done Test Driven Development?

Functions and Control Structures: Example Palindrome (UTF-8)

// IsPalindrome2 is using runes. This works for all UTF-8 chars (SBC, MBC).
func IsPalindrome2(word string) bool {
    var runes = []rune(word)
    for pos, ch := range runes {
        if ch != runes[len(runes)-pos-1] {
            return false
        }
    }
    return true
}

• The rune type is an alias for int32 and can store all UTF-8 characters
• []rune(string) converts a string into a slice of runes
• The range operator has two return values: the position and the current value

pos, ch := range runes

Functions and Control Structures: Example Palindrome (Reverse)

// IsPalindrome3 is implemented by reusing Reverse(). Reverse works for UTF-8 chars.
func IsPalindrome3(word string) bool {
    return strings.Reverse(word) == word
}

• Strings, arrays are compared in Go with ==
• Slices, Maps are compared with cmp.Equal

Pointers

Pointer I

A pointer is a variable which contains a memory address

func main() {
    var num int = 42
    ptr := &num
    
    fmt.Println("Value of num:", num)           
    // Expected Output: Value of num: 42
    
    fmt.Println("Address of num:", &num)        
    // Expected Output: Address of num: 0xSOME_MEMORY_ADDRESS (this will vary every run)
    
    fmt.Println("Value via pointer:", *ptr)     
    // Expected Output: Value via pointer: 42
    
    fmt.Println("Address stored in ptr:", ptr)  
    // Expected Output: Address stored in ptr: 0xSOME_MEMORY_ADDRESS (same as address of num)
}

Pointer I

func swap0(x, y int) (int, int) {
    return y, x
}

func swap1(x, y int) {
    x, y = y, x
}

func swap2(x *int, y *int) {
    *x, *y = *y, *x
}

func swap3(x **int, y **int) {
    *x, *y = *y, *x
}

• The double assignment saves a variable (tmp)!
• Pointers are transferred as well as values ​​by copy

Pointer II

func main() {
    var a, b = 1, 2
    fmt.Printf("Initial : a=%d, b=%d\n", a, b)

    a, b = b, a
    fmt.Printf("After a,b = b,a : a=%d, b=%d\n", a, b)

    swap0(a, b)
    fmt.Printf("After swap0(a,b) : a=%d, b=%d\n", a, b)

    a, b = swap0(a, b)
    fmt.Printf("After a,b = swap0(a,b) : a=%d, b=%d\n", a, b)

    swap1(a, b)
    fmt.Printf("After swap1(a,b) : a=%d, b=%d\n", a, b)

    swap2(&a, &b)
    fmt.Printf("After swap2(&a,&b) : a=%d, b=%d\n", a, b)

    pa, pb := &a, &b
    swap3(&pa, &pb)
    fmt.Printf("After swap3(&pa, &pb): a=%d, b=%d, *pa=%v, *pb=%v\n", a, b, *pa, *pb)
}

Exercise 2.1

github.com/s-macke/concepts-of-programming-languages/blob/master/docs/exercises/Exercise2.1.md

Maps and Slices - Example Book Index

// Page contains an array of words.
type Page []string

// Book is an array of pages.
type Book []Page

// Index contains a list of pages for each word in a book.
type Index map[string][]int

// MakeIndex generates an index structure
func MakeIndex(book Book) Index {
    idx := make(Index)
    for i, page := range book {
        for _, word := range page {
            pages := idx[word]
            idx[word] = append(pages, i)
        }
    }
    return idx
}

Stringer Interface

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func (p Person) String() string {
    return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}

func main() {
    person := Person{"Alice", 30}
    fmt.Println(person)
}

The Flag API simplifies Command Line Utilities

import (
    "flag"
    "fmt"
)

// Simple test for the Go flag API.
func main() {
    // construct a string flag with a default ip address and a description.
    ip := flag.String("ip", "192.168.1.1", "Overrides the default IP address.")
    port := flag.String("port", "8080", "Overrides the default listen port.")
    flag.Parse()

    fmt.Println("\nDefault value for IP: " + *ip)
    fmt.Println("\nDefault value for port: " + *port)
}

• execute the program with the argument "--help" to see the possible arguments and the suggestions

Summary

• Compiled (cross compiler for OS: Mac, Windows, Linux and CPU: ARM, x86 + Amd64)
• Static linker (Single Binary) -> Ideal for Docker containers
• Focus on fast compile times (the entire Go codebase compiles in <20 seconds)
• Simple (less keywords like C - 25/32) and Orthogonal
• Strong type system with runtime support (Reflection, Dynamic Types)

Exercise 2.2

github.com/s-macke/concepts-of-programming-languages/blob/master/docs/exercises/Exercise2.2.md

Thank you